home *** CD-ROM | disk | FTP | other *** search
/ Atari Forever 4 / Atari Forever 4.zip / Atari Forever 4.iso / SERIE_DM / DM_002 / DM_002.MSA / SEQUENC.C < prev    next >
C/C++ Source or Header  |  1986-02-06  |  7KB  |  297 lines
  1.  
  2.  
  3. /* -----------------------------------------------------------------------*/
  4. /* AS Sound Sampler  (Sequencer Demo Version Only)                        */
  5. /* GEM Anwendung                                                          */
  6. /* -----------------------------------------------------------------------*/
  7. /* Written 1986 by Andreas Lüning                                          */
  8. /* Application Service Software          Public Domain                     */
  9. /* -----------------------------------------------------------------------*/
  10. /* last Edit:  16.12.1986                                                 */
  11. /* Linkfiles:  gemstart,samplnk,aesbind,vdibind,gemlib,osbind,libf        */
  12. /* Hardware :  AD/DA Wandler am Centronics Druckerport                    */
  13. /* -----------------------------------------------------------------------*/
  14.  
  15.  
  16. /* Included Defs */
  17. /*----------------------------------------------------------------------- */
  18.  
  19. #include "sequenc.h"
  20. #include "sampinc.h"
  21.  
  22.  
  23. /* Definitions */
  24. /* ---------------------------------------------------------------------- */
  25.  
  26. #define  MAXSTEP        400
  27. #define  MAXBLOCK       60
  28.  
  29. /* ------------------- */
  30. /* etwas fuers Binding */
  31. /* ------------------- */
  32.  
  33. int contrl[12];
  34. int intin[128];
  35. int ptsin[128];
  36. int intout[128];
  37. int ptsout[128];
  38.  
  39. /* ------------------------------------------ */
  40. /* Typenvereinbarungen zur Speicherverwaltung */
  41. /* ------------------------------------------ */
  42.  
  43. typedef struct selmark
  44. {
  45. long  seqbegin;
  46. long  seqlength;
  47. char  seqname[20];
  48. } BLOCK;
  49.  
  50. typedef struct sequenc
  51. {
  52. int   index;
  53. int   speed;
  54. int   repeat;
  55. int   offset;
  56. } SEQUENC;
  57.  
  58. /* globale Variablen */
  59. /* ------------------------------------------------------------- */
  60.  
  61. int   handle;
  62. int   phys_handle;
  63.  
  64.  
  65. /* Speicher */
  66. /* ------------------------- */
  67.  
  68. BLOCK    memblock[MAXBLOCK];
  69. SEQUENC  seqlist[MAXSTEP];
  70.  
  71. long  g_len,g_buf;
  72. long  r_len,r_buf;  
  73.  
  74. GRCT  desk;
  75.  
  76. /* Strings */
  77. /* -------------------------- */
  78.  
  79. char  file_name[64] = { "" };
  80. char  *wrterr       = { "[1][Write Error on your Disk][ Abort ]" };
  81. char  *rderr        = { "[1][Read Error on your Disk][ Abort ]" };
  82. char  *trouble      = { "[2][Trouble using your Disk][ Again | Abort ]" };
  83. char  remark[160];
  84.  
  85. dialog(index,text)
  86. int index,text;
  87. {
  88. long tree;
  89. int  x,y,w,h;
  90. int  ex_butt;
  91.  
  92.    resource(index);
  93.    form_center(tree,&x,&y,&w,&h);
  94.    form_dial(0,x,y,w,h,x,y,w,h);
  95.    objc_draw(tree,0,8,desk.x,desk.y,desk.w,desk.h);
  96.    ex_butt=form_do(tree,text);
  97.    objc_change(tree,ex_butt,0,x,y,w,h,32,1);
  98.    form_dial(3,x,y,w,h,x,y,w,h);
  99.    return(ex_butt);
  100. }
  101.  
  102.  
  103. loadseq()
  104. {
  105. int  fhandle,i;
  106. long length=0L;
  107.  
  108.    if(get_file("*.SEQ")==0) return(0);
  109.    while((fhandle=Fopen(file_name,0))<0)
  110.       if(form_alert(1,trouble)==2) return(0);
  111.  
  112.    if(Fread(fhandle,160L,remark)<0)
  113.    {  form_alert(1,rderr);
  114.       return(0);
  115.    }
  116.  
  117.    for(i=0;i<MAXBLOCK;i++)
  118.    {  if(Fread(fhandle,4L,&memblock[i].seqbegin)<0)
  119.       {  form_alert(1,rderr);
  120.          return(0);
  121.       }
  122.       if(memblock[i].seqbegin== -1L) break;
  123.       memblock[i].seqbegin+=g_buf;
  124.       if(Fread(fhandle,20L,&memblock[i].seqlength)<0)
  125.       {  form_alert(1,rderr);
  126.          return(0);
  127.       }
  128.       length+=memblock[i].seqlength;
  129.    }
  130.  
  131.    if(length>g_len)
  132.    {  form_alert(1,"[3][There is not enough|Memory to load the|Sequence][ OK ]");
  133.       return(0);
  134.       }
  135.  
  136.    for(i=0;i<MAXSTEP;i++)
  137.    {  if(Fread(fhandle,2L,&seqlist[i].index)<0)
  138.       {  form_alert(1,rderr);
  139.          return(0);
  140.       }
  141.       if(seqlist[i].index== -1) break;
  142.       if(Fread(fhandle,6L,&seqlist[i].speed)<0)
  143.       {  form_alert(1,rderr);
  144.          return(0);
  145.       }
  146.    }
  147.  
  148.    if(Fread(fhandle,length,g_buf)<0)
  149.    {  form_alert(1,rderr);
  150.       return(0);
  151.    }
  152.  
  153.    Fclose(fhandle);
  154.    return(1);
  155. }
  156.  
  157. /* ------------- */
  158. /* File Selector */
  159. /* ------------- */
  160.  
  161. get_file(path)
  162. char *path;
  163. {
  164. int   exbutt;
  165. char  f_name[14];
  166.  
  167.    get_path(file_name,path);
  168.    f_name[0]='\0';
  169.    graf_mouse(M_ON,0L);
  170.    fsel_input(file_name,f_name,&exbutt);
  171.    graf_mouse(M_OFF,0L);
  172.    if(exbutt)
  173.    {  add_file_name(file_name,f_name);
  174.       return(1);
  175.    }
  176.    else return(0);
  177. }
  178.  
  179. get_path(path,spec)
  180. char  *path,*spec;
  181. {
  182. int   drive;
  183.  
  184.    drive=Dgetdrv();
  185.    path[0]=drive+'A';
  186.    path[1]=':';
  187.    path[2]='\\';
  188.    Dgetpath(&path[3],drive+1);
  189.    if(strlen(path)>3) strcat(path,"\\");
  190.    else               path[3]='\0';
  191.    strcat(path,spec);
  192. }
  193.  
  194. add_file_name(dname,fname)
  195. char  *dname,*fname;
  196. {
  197. char  c;
  198. int   i;
  199.  
  200.    i=strlen(dname);
  201.    while(i&&(((c=dname[i-1])!='\\')&&(c!=':'))) i--;
  202.    dname[i]='\0';
  203.    strcat(dname,fname);
  204. }
  205. /* ------------------ */
  206. /* do_info            */
  207. /* ------------------ */
  208.  
  209. do_info()
  210. {
  211. dialog(INF,0);
  212. }
  213.  
  214.  
  215. /* ------------------ */
  216. /* Handle ANALOG-PORT */
  217. /* ------------------ */
  218.  
  219. do_sequence(port)
  220. int port;
  221. {
  222. int  i,r,block;
  223. long buffer,length;
  224.  
  225.    graf_mouse(M_OFF,0L);
  226.    Bconout(4,0x13);
  227.    if(port) smpon();
  228.    for(i=0;i<MAXSTEP;i++)
  229.    {
  230.       if(seqlist[i].index== -1) break;
  231.       block=seqlist[i].index;
  232.       buffer=memblock[block].seqbegin;
  233.       length=memblock[block].seqlength;
  234.       if(seqlist[i].offset<0) buffer+=length-1;
  235.       for(r=0;r<seqlist[i].repeat;r++)
  236.       {  if(port) speaker(buffer,length,(99-seqlist[i].speed)+6,seqlist[i].offset);
  237.          else     output(buffer,length,(99-seqlist[i].speed)+9,seqlist[i].offset);
  238.       }
  239.    }
  240.    if(port) smpoff();
  241.    Bconout(4,0x11);
  242.    graf_mouse(M_ON,0L);
  243. }
  244.  
  245.  
  246. /* ------------- */
  247. /* Hauptprogramm */
  248. /* ------------- */
  249.  
  250. main()
  251. {
  252. int   i;
  253. int   dummy;
  254. int   work_in[11],work_out[57];
  255. int   end=0;
  256.  
  257.    appl_init();
  258.    for(i=0;i<10;work_in[i++]=1);
  259.    work_in[10]=2;
  260.    v_opnvwk(work_in,&handle,work_out);
  261.  
  262.    wind_get(0,WF_WORKXYWH,&desk.x,&desk.y,&desk.w,&desk.h);
  263.    graf_mouse(ARROW,0L);
  264.  
  265.    g_len=Malloc(-1L)-10000;
  266.  
  267.    if(g_len<0L)  form_alert(1,"[3][Out Of Memory][ OK ]");
  268.    else
  269.    {  g_buf=Malloc(g_len);              
  270.       if(rsrc_load("sequenc.rsc")!=0)
  271.       { graf_mouse(M_OFF,0L);
  272.         if(loadseq())
  273.         {  graf_mouse(M_ON,0L);
  274.            while(!end)
  275.               switch(dialog(BOX,0))
  276.               {  
  277.                   case DA: do_sequence(0);
  278.                            break;
  279.  
  280.                   case SPEAKER: do_sequence(1);
  281.                                 break;
  282.   
  283.                   case QUIT: end=TRUE;
  284.                              break;
  285.  
  286.                   case INFORMA: do_info();
  287.                                 break;
  288.                }        
  289.          }
  290.       } 
  291.   }
  292.  
  293.    v_clsvwk(handle);
  294.    appl_exit();
  295. }
  296.  
  297.